package com.hyjr.RxTask.netty.handler;

import com.hyjr.RxTask.bcprov.SM2Utils;
import com.hyjr.RxTask.common.Constants;
import com.hyjr.RxTask.rabbitmq.ProducerUtil;
import com.hyjr.RxTask.rabbitmq.RabbitmqConstants;
import com.hyjr.bean.TaskBean;
import com.hyjr.common.data.ResultData;
import com.hyjr.common.enums.CheckTypeEnum;
import com.hyjr.common.utils.LogUtils;
import com.hyjr.common.utils.PropertyUtil;
import com.hyjr.common.utils.Utils;

import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;
import io.netty.util.internal.StringUtil;

public class ReceiveTaskServerHandler extends ChannelInboundHandlerAdapter {

	@Override
	public void channelActive(ChannelHandlerContext ctx) throws Exception {
		super.channelActive(ctx);
		LogUtils.debug("检测端，服务端ReceiveTaskServerHandler，channelActive");
	}

	@Override
	public void channelInactive(ChannelHandlerContext ctx) throws Exception {
		super.channelInactive(ctx);
		LogUtils.debug("检测端，服务端ReceiveTaskServerHandler，channelInactive");
		ctx.flush();
		ctx.close();
	}

	@Override
	public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
		if (msg instanceof TaskBean) {
			TaskBean taskBean = (TaskBean) msg;

			LogUtils.debug("检测端，服务端ReceiveTaskServerHandler，服务端获取的数据：" + taskBean.toString());
			
			if(StringUtil.isNullOrEmpty(taskBean.getEncrFileInfo())) {
				LogUtils.debug("检测端，服务端ReceiveTaskServerHandler，返回的数据：加密文件信息不可为空！");
				ctx.writeAndFlush(new ResultData(Constants.RET_ERROR_CODE, "加密文件信息不可为空！"));
				return ;
			}
			
			if(StringUtil.isNullOrEmpty(taskBean.getCheckTypes())) {
				LogUtils.debug("检测端，服务端ReceiveTaskServerHandler，返回的数据：检测类型不可为空！");
				ctx.writeAndFlush(new ResultData(Constants.RET_ERROR_CODE, "检测类型不可为空！"));
				return ;
			}
			
			String[] checkTypeArr = taskBean.getCheckTypes().split(",");
			for(String checkType : checkTypeArr) {
				if(CheckTypeEnum.getEnumByKey(checkType) == null) {
					LogUtils.debug("检测端，服务端ReceiveTaskServerHandler，返回的数据：检测类型[" + checkType + "]不正确！");
					ctx.writeAndFlush(new ResultData(Constants.RET_ERROR_CODE, "检测类型[" + checkType + "]不正确！"));
					return ;
				}
			}
			
			//公钥KEY
			String privateKey = PropertyUtil.getPropety("bcprov", "E2_pri_key");
			
			//解密
			String decrFileInfo = null;
			try {
				decrFileInfo = SM2Utils.decrypt(privateKey, taskBean.getEncrFileInfo());
			} catch (Exception e) {
				LogUtils.debug("检测端，服务端ReceiveTaskServerHandler，返回的数据：加密文件解密错误！");
				ctx.writeAndFlush(new ResultData(Constants.RET_ERROR_CODE, "加密文件解密错误！"));
				return ;
			}
			taskBean.setDecrFileInfo(decrFileInfo);
			
			//任务生成ID
			taskBean.setTaskId(Utils.getUUID());
			
			//检测任务没有问题后，将其放入队列中
			try {
				ProducerUtil.producer(RabbitmqConstants.REQ_TASK_INFO, taskBean);
				LogUtils.debug("检测端，服务端ReceiveTaskServerHandler，将任务数据放入队列中，任务数据：" + taskBean.toString());
			} catch (Exception e) {
				LogUtils.debug("检测端，服务端ReceiveTaskServerHandler，返回的数据：系统异常！");
				e.printStackTrace();
				ctx.writeAndFlush(new ResultData(Constants.RET_ERROR_CODE, "系统异常！"));
				return ;
			}
			
			ctx.writeAndFlush(new ResultData(taskBean.getTaskId()));
		}
	}

	@Override
	public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) {
		cause.printStackTrace();
		LogUtils.debug("检测端，客户端ReceiveTaskServerHandler，exceptionCaught", cause);
		ctx.close();
	}
}
